from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.pipeline import make_pipeline
from sklearn.impute import SimpleImputer
from sklearn.model_selection import cross_val_score, cross_validate
from sklearn.model_selection import StratifiedKFold
import pandas as pd
import numpy as np
import os
import warnings
warnings.filterwarnings('ignore', category=FutureWarning)
import altair as alt
import altair_ally as ally
from altair import datum

# Enable Altair to render in Jupyter
alt.data_transformers.enable('json', prefix='../data/altair/')

DataTransformerRegistry.enable('json')

from ucimlrepo import fetch_ucirepo 
  
# fetch dataset 
bank_marketing = fetch_ucirepo(id=222) 
  
# data (as pandas dataframes) 
X = bank_marketing.data.features 
y = bank_marketing.data.targets

# Define the folder path
folder_path = '../data/'
altair_path = '../data/altair/'

# Ensure the directory exists (create it if it doesn't)
os.makedirs(folder_path, exist_ok=True)
os.makedirs(altair_path, exist_ok=True)

# Define file paths
features_file_path = os.path.join(folder_path, 'bank_marketing_features.csv')
targets_file_path = os.path.join(folder_path, 'bank_marketing_targets.csv')

# Export the DataFrames to CSV
X.to_csv(features_file_path, index=False) # index=False prevents pandas from writing row indices to the file
y.to_csv(targets_file_path, index=False)

df = pd.concat([X, y], axis=1)

# to ignore warning messages from python ally
warnings.filterwarnings(
    "ignore",
    message="You passed a `<class 'narwhals.stable.v1.DataFrame'>` to `is_pandas_dataframe`.",
    category=UserWarning,
    module="altair.utils.data"
)

df.head()

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 45211 entries, 0 to 45210
Data columns (total 17 columns):
 #   Column       Non-Null Count  Dtype 
---  ------       --------------  ----- 
 0   age          45211 non-null  int64 
 1   job          44923 non-null  object
 2   marital      45211 non-null  object
 3   education    43354 non-null  object
 4   default      45211 non-null  object
 5   balance      45211 non-null  int64 
 6   housing      45211 non-null  object
 7   loan         45211 non-null  object
 8   contact      32191 non-null  object
 9   day_of_week  45211 non-null  int64 
 10  month        45211 non-null  object
 11  duration     45211 non-null  int64 
 12  campaign     45211 non-null  int64 
 13  pdays        45211 non-null  int64 
 14  previous     45211 non-null  int64 
 15  poutcome     8252 non-null   object
 16  y            45211 non-null  object
dtypes: int64(7), object(10)
memory usage: 5.9+ MB

df.describe()

ally.alt.data_transformers.enable('vegafusion')
ally.dist(df, color='y')

ally.corr(df)

# Simple pipeline example
numeric_pipeline = make_pipeline(
    SimpleImputer(strategy='median'),
    StandardScaler()
)

categorical_pipeline = make_pipeline(
    SimpleImputer(strategy='constant', fill_value='unknown'),
    OneHotEncoder(drop='first')
)

# First, let's prepare the data
# Handle categorical variables in features
categorical_columns = X.select_dtypes(include=['object']).columns.tolist()
numerical_columns = X.select_dtypes(include=['int64', 'float64']).columns.tolist()

print(f"Categorical columns: {categorical_columns}")
print(f"Numerical columns: {numerical_columns}")

Categorical columns: ['job', 'marital', 'education', 'default', 'housing', 'loan', 'contact', 'month', 'poutcome']
Numerical columns: ['age', 'balance', 'day_of_week', 'duration', 'campaign', 'pdays', 'previous']

# Create preprocessing pipeline
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_pipeline, numerical_columns),
        ('cat', categorical_pipeline, categorical_columns)
    ])

full_pipeline = make_pipeline(
    preprocessor,
    LogisticRegression(random_state=522, max_iter=2000, class_weight="balanced")
)

# Prepare target variable
# LabelEncoder just creates a simple mapping - no statistics involved
label_encoder = LabelEncoder()
y_encoded = label_encoder.fit_transform(y.values.ravel())

# What it does:
# 'no'  → 0
# 'yes' → 1

print(f"Target classes: {label_encoder.classes_}")
# Note: ravel() converts your 2D DataFrame column (522, 1) into a 1D array (522,) so LabelEncoder can process it properly!

Target classes: ['no' 'yes']

# Split the data
# 'stratify=y_encoded' ensures that your train and test sets have the same class distribution as your original dataset.
X_train, X_test, y_train, y_test = train_test_split(
    X, y_encoded, test_size=0.2, random_state=522, stratify=y_encoded
)

print(f"Training set size: {X_train.shape}")
print(f"Test set size: {X_test.shape}")

Training set size: (36168, 16)
Test set size: (9043, 16)

# Use stratified CV for imbalanced data
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=522)
cv_results = cross_validate(
    full_pipeline,
    X,
    y_encoded,
    cv=skf,  # ← Use stratified splits!
    scoring={'accuracy': 'accuracy', 'f1': 'f1', 'peri''roc_auc': 'roc_auc'},
    return_train_score=True,
    n_jobs=-1
)

pd.DataFrame(cv_results).agg(['mean', 'std']).round(3).T

# imports 
import pandera.pandas as pa

df.head()

# defining the schema
schema = pa.DataFrameSchema({
    "age": pa.Column(int, pa.Check.between(15, 120)),
    
    "job": pa.Column(
        str,
        pa.Check.isin(["admin.","unknown","unemployed","management","housemaid","entrepreneur","student",
                                       "blue-collar","self-employed","retired","technician","services"])
    ),

    "marital": pa.Column(
        str,
        pa.Check.isin(["married", "single", "divorced"])

    ),

    "education": pa.Column(
        str, 
        pa.Check.isin(["unknown","secondary","primary","tertiary"])
        ),

    "default": pa.Column(
        str,
        pa.Check.isin(["yes", "no", "unknown"])
    ),

    "balance": pa.Column(
        int,
        checks=[
            pa.Check.ge(-5000),
            pa.Check.le(500000)
        ]
    ),

    "housing": pa.Column(
        str,
        pa.Check.isin(["yes", "no"])
    ),

    "loan": pa.Column(
        str,
        pa.Check.isin(["yes", "no"])
    ),

    "contact": pa.Column(
        str,
        pa.Check.isin(["cellular", "telephone", "unknown"])
    ),

    "day_of_week": pa.Column(
        int,
        pa.Check.isin([1, 2, 3, 4, 5, 6, 7])
    ),

    "month": pa.Column(
        str,
        pa.Check.isin(["jan", "feb", "mar", "apr", "may", "jun",
                       "jul", "aug", "sep", "oct", "nov", "dec"])
    ),

    "duration": pa.Column(
        int,
        checks=[
            pa.Check.ge(0),
            pa.Check.le(3600)
        ]
    ),

    "campaign": pa.Column(
        int,
        checks=[
            pa.Check.ge(1),
            pa.Check.le(300)
        ]
    ),

    "previous": pa.Column(
        int,
        checks=[
            pa.Check.ge(0),
            pa.Check.le(24)
        ]
    ),

    "poutcome": pa.Column(
        str,
        pa.Check.isin(["unknown", "other", "failure", "success"])
    ),

    "y": pa.Column(
        str,
        pa.Check.isin(["yes", "no"])
    ),    
})

# count number of failures per column
try:
    schema.validate(df, lazy=True)
except pa.errors.SchemaErrors as err:
    print(err.failure_cases["column"].value_counts())

column
poutcome       36959
day_of_week    35413
contact        13020
education       1857
job              288
previous          32
duration           3
balance            2
Name: count, dtype: int64

# unique errors per column
try:
    schema.validate(df, lazy=True)
except pa.errors.SchemaErrors as err:
    print(err.failure_cases.groupby("column")["failure_case"].nunique())

column
balance         2
contact         0
day_of_week    24
duration        3
education       0
job             0
poutcome        0
previous       16
Name: failure_case, dtype: int64

df["day_of_week"].unique()

array([ 5,  6,  7,  8,  9, 12, 13, 14, 15, 16, 19, 20, 21, 23, 26, 27, 28,
       29, 30,  2,  3,  4, 11, 17, 18, 24, 25,  1, 10, 22, 31])

# uncomment below to see full error message
# validated_df = schema.validate(df, lazy = True)

import pandera as pa
from pandera import DataFrameSchema, Check

# Function to check duplicates per column
def duplicate_columns_report(df: pd.DataFrame):
    report = []
    for col in df.columns:
        duplicated_count = df.duplicated(subset=[col]).sum()
        report.append({
            "column": col,
            "total_rows": len(df),
            "duplicated_observations": duplicated_count,
            "unique_observations": len(df) - duplicated_count,
            "has_duplicates": duplicated_count > 0,
            "percent_duplicates": duplicated_count / len(df) * 100
        })
    return pd.DataFrame(report)

# define a DataFrame-level Pandera check to enforce no duplicates for the whole DataFrame
def no_duplicates_df(df: pd.DataFrame):
    return df.duplicated().sum() == 0 

schema = DataFrameSchema(
    checks=[
        Check(
            no_duplicates_df,
            element_wise=False,
            error="DataFrame contains duplicate rows"
        )
    ]
)

# Validate the DataFrame (collect all failures)
try:
    schema.validate(df, lazy=True)
except pa.errors.SchemaErrors as e:
    print("DataFrame-level duplicate check failed")
    print(e.failure_cases)

# Generate a report for each column
column_duplicates_report = duplicate_columns_report(df)
print(column_duplicates_report)

         column  total_rows  duplicated_observations  unique_observations  \
0           age       45211                    45134                   77   
1           job       45211                    45199                   12   
2       marital       45211                    45208                    3   
3     education       45211                    45207                    4   
4       default       45211                    45209                    2   
5       balance       45211                    38043                 7168   
6       housing       45211                    45209                    2   
7          loan       45211                    45209                    2   
8       contact       45211                    45208                    3   
9   day_of_week       45211                    45180                   31   
10        month       45211                    45199                   12   
11     duration       45211                    43638                 1573   
12     campaign       45211                    45163                   48   
13        pdays       45211                    44652                  559   
14     previous       45211                    45170                   41   
15     poutcome       45211                    45207                    4   
16            y       45211                    45209                    2   

    has_duplicates  percent_duplicates  
0             True           99.829687  
1             True           99.973458  
2             True           99.993364  
3             True           99.991153  
4             True           99.995576  
5             True           84.145451  
6             True           99.995576  
7             True           99.995576  
8             True           99.993364  
9             True           99.931433  
10            True           99.973458  
11            True           96.520758  
12            True           99.893831  
13            True           98.763575  
14            True           99.909314  
15            True           99.991153  
16            True           99.995576

from pandera import Column, DataFrameSchema, Check

# Define threshold
MISSING_THRESHOLD = 0.05  # 5%

# Custom check function for missingness
def missing_within_threshold(series, threshold=MISSING_THRESHOLD):
    # Returns True if fraction of missing values is within the threshold
    return series.isna().mean() <= threshold

# Create schema with a missingness check for all columns
schema_columns = {
    col: Column(
        nullable=True,
        checks=[
            Check(
                lambda s: missing_within_threshold(s),
                element_wise=False,
                error=f"Missing values exceed {MISSING_THRESHOLD*100}%"
            )
        ]
    )
    for col in df.columns
}

schema = DataFrameSchema(schema_columns)

# Validate in lazy mode to collect all errors
try:
    schema.validate(df, lazy=True)
except pa.errors.SchemaErrors as e:
    # e.failure_cases has all validation failures
    print("Some columns exceeded the missingness threshold")

report = pd.DataFrame({
    "total_missing": df.isna().sum(),
    "missing_fraction": df.isna().mean(),
    "exceeds_threshold": df.isna().mean() > MISSING_THRESHOLD
})

print(report)

             total_missing  missing_fraction  exceeds_threshold
age                      0          0.000000              False
job                    288          0.006370              False
marital                  0          0.000000              False
education             1857          0.041074              False
default                  0          0.000000              False
balance                  0          0.000000              False
housing                  0          0.000000              False
loan                     0          0.000000              False
contact              13020          0.287983               True
day_of_week              0          0.000000              False
month                    0          0.000000              False
duration                 0          0.000000              False
campaign                 0          0.000000              False
pdays                    0          0.000000              False
previous                 0          0.000000              False
poutcome             36959          0.817478               True
y                        0          0.000000              False

from pandera import DataFrameSchema, Column, Check

# Expected target distribution
expected_distribution = {"no": 0.5, "yes": 0.5}
tolerance = 0.05  # ±5% allowed

# Custom function for Pandera to check if the distribution is within tolerance
def check_target_distribution(series: pd.Series) -> bool:
    counts = series.value_counts(normalize=True)
    for cat, expected_prop in expected_distribution.items():
        observed_prop = counts.get(cat, 0)
        if abs(observed_prop - expected_prop) > tolerance:
            return False  # fail if any category is out of tolerance
    return True  # pass if all categories are within tolerance

# Create a schema for the target column
schema = DataFrameSchema({
    "y": Column(
        pa.String,
        checks=[
            Check(
                check_target_distribution,
                element_wise=False,
                error="Target distribution is outside the expected tolerance"
            )
        ],
        nullable=False
    )
})

try:
    schema.validate(df, lazy=True)
except pa.errors.SchemaErrors as e:
    print("Target distribution check failed:")
    print(e.failure_cases)

def target_distribution_report(series: pd.Series):
    counts = series.value_counts(normalize=True)
    report = []
    for cat, expected_prop in expected_distribution.items():
        obs_prop = counts.get(cat, 0)
        within_tol = abs(obs_prop - expected_prop) <= tolerance
        report.append({
            "category": cat,
            "observed": obs_prop,
            "expected": expected_prop,
            "within_tolerance": within_tol
        })
    return pd.DataFrame(report)

report = target_distribution_report(df["y"])
print(report)

Target distribution check failed:
  column  failure_case index schema_context  \
0      y         False  None         Column   

                                               check  check_number  
0  Target distribution is outside the expected to...             0  
  category  observed  expected  within_tolerance
0       no  0.883015       0.5             False
1      yes  0.116985       0.5             False

import numpy as np
from scipy.stats import chi2_contingency

# -------------------------
# CORRELATION FUNCTIONS
# -------------------------

def cramers_v(x, y):
    confusion = pd.crosstab(x, y)
    chi2 = chi2_contingency(confusion)[0]
    n = confusion.sum().sum()
    phi2 = chi2 / n
    r, k = confusion.shape
    return np.sqrt(phi2 / min(k - 1, r - 1))

def correlation_ratio(categories, values):
    categories = categories.astype(str)
    values = values.astype(float)
    means, counts = [], []
    overall_mean = np.mean(values)
    for cat in np.unique(categories):
        vals = values[categories == cat]
        means.append(np.mean(vals))
        counts.append(len(vals))
    between = np.sum(counts * (means - overall_mean)**2)
    total = np.sum((values - overall_mean)**2)
    return np.sqrt(between / total) if total != 0 else 0

# -------------------------
# TARGET-FEATURE CORRELATION
# -------------------------

def target_correlation_report(df, target="y", threshold=0.8):
    correlations = []
    y = df[target]

    for col in df.columns:
        if col == target:
            continue
        x = df[col]
        if np.issubdtype(x.dtype, np.number) and np.issubdtype(y.dtype, np.number):
            corr = abs(x.corr(y))
        elif x.dtype == "object" and y.dtype == "object":
            corr = cramers_v(x, y)
        else:
            if np.issubdtype(x.dtype, np.number):
                corr = correlation_ratio(y.astype(str), x)
            else:
                corr = correlation_ratio(x.astype(str), y)
        correlations.append({"feature": col, "correlation": corr, "anomalous": corr > threshold})

    report = pd.DataFrame(correlations)
    anomalous = report[report["anomalous"]]
    return report, anomalous

# -------------------------
# FEATURE-FEATURE CORRELATION
# -------------------------

def feature_correlation_report(df, target="y", threshold=0.8):
    features = df.drop(columns=[target])
    cols = features.columns
    results = []

    for i, c1 in enumerate(cols):
        for c2 in cols[i+1:]:
            x, y_ = features[c1], features[c2]
            if np.issubdtype(x.dtype, np.number) and np.issubdtype(y_.dtype, np.number):
                corr = abs(x.corr(y_))
            elif x.dtype == "object" and y_.dtype == "object":
                corr = cramers_v(x, y_)
            else:
                if np.issubdtype(x.dtype, np.number):
                    corr = correlation_ratio(y_.astype(str), x)
                else:
                    corr = correlation_ratio(x.astype(str), y_)
            results.append({"feature_1": c1, "feature_2": c2, "correlation": corr, "anomalous": corr > threshold})

    report = pd.DataFrame(results)
    anomalous = report[report["anomalous"]]
    return report, anomalous

# -------------------------
# USAGE
# -------------------------

target_report, anomalous_target = target_correlation_report(df, target="y", threshold=0.8)
feature_report, anomalous_features = feature_correlation_report(df, target="y", threshold=0.8)

# -------------------------
# PRINT REPORTS
# -------------------------
print("\n--- TARGET vs FEATURES CORRELATION ---")
print(target_report)
if not anomalous_target.empty:
    print("\n--- ANOMALOUS TARGET CORRELATIONS ---")
    print(anomalous_target)

print("\n--- FEATURE vs FEATURE CORRELATION ---")
print(feature_report)
if not anomalous_features.empty:
    print("\n--- ANOMALOUS FEATURE-FEATURE CORRELATIONS ---")
    print(anomalous_features)

--- TARGET vs FEATURES CORRELATION ---
        feature  correlation  anomalous
0           age     0.025155      False
1           job     0.136429      False
2       marital     0.065926      False
3     education     0.073427      False
4       default     0.022160      False
5       balance     0.052838      False
6       housing     0.139103      False
7          loan     0.068091      False
8       contact     0.011945      False
9   day_of_week     0.028348      False
10        month     0.260237      False
11     duration     0.394521      False
12     campaign     0.073172      False
13        pdays     0.103621      False
14     previous     0.093236      False
15     poutcome     0.469914      False

--- FEATURE vs FEATURE CORRELATION ---
    feature_1  feature_2  correlation  anomalous
0         age        job     0.501129      False
1         age    marital     0.433431      False
2         age  education     0.215201      False
3         age    default     0.017879      False
4         age    balance     0.097783      False
..        ...        ...          ...        ...
115  campaign   previous     0.032855      False
116  campaign   poutcome     0.112405      False
117     pdays   previous     0.454820      False
118     pdays   poutcome     0.878962       True
119  previous   poutcome     0.539278      False

[120 rows x 4 columns]

--- ANOMALOUS FEATURE-FEATURE CORRELATIONS ---
    feature_1 feature_2  correlation  anomalous
118     pdays  poutcome     0.878962       True

	age	balance	day_of_week	duration	campaign	pdays	previous
count	45211.000000	45211.000000	45211.000000	45211.000000	45211.000000	45211.000000	45211.000000
mean	40.936210	1362.272058	15.806419	258.163080	2.763841	40.197828	0.580323
std	10.618762	3044.765829	8.322476	257.527812	3.098021	100.128746	2.303441
min	18.000000	-8019.000000	1.000000	0.000000	1.000000	-1.000000	0.000000
25%	33.000000	72.000000	8.000000	103.000000	1.000000	-1.000000	0.000000
50%	39.000000	448.000000	16.000000	180.000000	2.000000	-1.000000	0.000000
75%	48.000000	1428.000000	21.000000	319.000000	3.000000	-1.000000	0.000000
max	95.000000	102127.000000	31.000000	4918.000000	63.000000	871.000000	275.000000

	mean	std
fit_time	0.130	0.003
score_time	0.029	0.001
test_accuracy	0.844	0.004
train_accuracy	0.845	0.001
test_f1	0.551	0.008
train_f1	0.554	0.002
test_periroc_auc	0.910	0.004
train_periroc_auc	0.911	0.001

Term Deposit Predictor¶

Summary¶

Introduction¶

Methods¶

Data¶

Analysis¶

Results and Discussion¶

Data Validation¶

References¶

	age	job	marital	education	default	balance	housing	loan	contact	day_of_week	month	duration	campaign	pdays	poutcome	y
0	58	management	married	tertiary	no	2143	yes	no	NaN	5	may	261	1	-1	NaN	no
1	44	technician	single	secondary	no	29	yes	no	NaN	5	may	151	1	-1	NaN	no
2	33	entrepreneur	married	secondary	no	2	yes	yes	NaN	5	may	76	1	-1	NaN	no
3	47	blue-collar	married	NaN	no	1506	yes	no	NaN	5	may	92	1	-1	NaN	no
4	33	NaN	single	NaN	no	1	no	no	NaN	5	may	198	1	-1	NaN	no